import { Inject, Controller, Get, Query, Post, Body } from '@midwayjs/core';
import { Context } from '@midwayjs/koa';
import { UserService } from '../service/user.service';
import { DatabaseService } from '../service/database.service';
import axios from "axios";

@Controller('/api')
export class APIController {
  @Inject()
  ctx: Context;

  @Inject()
  userService: UserService;

  @Inject()
  databaseService: DatabaseService;

  // dmxapi配置
  private readonly apiConfig = {
    url: 'https://www.dmxapi.cn/v1/chat/completions',
    headers: {
      'Authorization': 'Bearer sk-834gcXipdT1A0OWbJWGDtMQMuuqENTNhGUbenwENstQF7rpb',
      'Content-Type': 'application/json'
    }
  };


  @Get('/get_user')
  async getUser(@Query('uid') uid) {
    const user = await this.userService.getUser({ uid });
    return { success: true, message: 'OK', data: user };
  }

  /**
   * AI问答接口（带缓存功能）
   * @param prompt 用户输入的问题
   */
  @Post('/askai')
  async askAi(@Body() body: { prompt: string }) {
    try {
      const { prompt } = body;

      if (!prompt) {
        return { success: false, message: '请提供问题内容', data: null };
      }

      // 1. 先查询缓存
      const cachedResult = await this.databaseService.getCacheByPrompt(prompt);
      if (cachedResult) {
        return {
          success: true,
          message: '查询成功（缓存）',
          data: {
            resultContent: cachedResult,
            timestamp: new Date().toISOString(),
            fromCache: true
          }
        };
      }

      // 2. 缓存中没有，调用dmxapi接口
      const requestData = {
        max_tokens: 8192,
        model: "gemini-2.0-flash",
        temperature: 0.8,
        top_p: 1,
        presence_penalty: 1,
        messages: [
          {
            role: "system",
            content: "你是一个老师"
          },
          {
            role: "user",
            content: prompt
          }
        ]
      };

      const response = await axios.post(
        this.apiConfig.url,
        requestData,
        {
          headers: this.apiConfig.headers,
          timeout: 30000 // 30秒超时
        }
      );
      
      const airesult = response?.data?.choices?.[0]?.message?.content;

      // 3. 保存结果到缓存
      if (airesult) {
        await this.databaseService.saveCacheResult(prompt, airesult);
      }

      return {
        success: true,
        message: '查询成功',
        data: {
          resultContent: airesult,
          timestamp: new Date().toISOString(),
          fromCache: false
        }
      };

    } catch (error) {
      console.error('AI查询错误:', error);
      return { success: false, message: '查询失败，请重试', data: null };
    }
  }

  /**
   * AI文章总结接口（带缓存功能）
   * @param url 文章URL地址
   * @param content 文章内容（可选）
   */
  @Post('/ai/summary')
  async aiSummary(@Body() body: { url: string; content?: string }) {
    try {
      const { url, content } = body;

      if (!url) {
        return { success: false, message: '请提供文章URL地址', data: null };
      }

      // 使用URL作为缓存键
      const cacheKey = `summary_${url}`;

      // 1. 先查询缓存
      const cachedResult = await this.databaseService.getCacheByPrompt(cacheKey);
      if (cachedResult) {
        return {
          success: true,
          message: '总结成功（缓存）',
          data: {
            summary: cachedResult,
            url: url,
            timestamp: new Date().toISOString(),
            fromCache: true
          }
        };
      }

      // 2. 缓存中没有，调用dmxapi接口进行总结
      const promptContent = content 
        ? `根据这篇内容：${content}，总结文章` 
        : `请访问这个URL：${url}，并总结文章内容`;

      const requestData = {
        max_tokens: 8192,
        model: "gemini-2.0-flash",
        temperature: 0.7,
        top_p: 1,
        presence_penalty: 1,
        messages: [
          {
            role: "system",
            content: "你是一个专业的文章总结助手，能够准确提取文章的核心内容并生成简洁明了的总结。"
          },
          {
            role: "user",
            content: promptContent
          }
        ]
      };

      const response = await axios.post(
        this.apiConfig.url,
        requestData,
        {
          headers: this.apiConfig.headers,
          timeout: 45000 // 45秒超时，总结可能需要更长时间
        }
      );
      
      const summaryResult = response?.data?.choices?.[0]?.message?.content;

      // 3. 保存结果到缓存
      if (summaryResult) {
        await this.databaseService.saveCacheResult(cacheKey, summaryResult);
      }

      return {
        success: true,
        message: '总结成功',
        data: {
          summary: summaryResult,
          url: url,
          timestamp: new Date().toISOString(),
          fromCache: false
        }
      };

    } catch (error) {
      console.error('AI文章总结错误:', error);
      return { success: false, message: '总结失败，请重试', data: null };
    }
  }

  /**
   * 文本格式化接口（将文本切割成句子列表）
   * @param text 要格式化的文本内容
   */
  @Post('/formatelin')
  async formatTextToSentences(@Body() body: { text: string }) {
    try {
      const { text } = body;

      if (!text || !text.trim()) {
        return { success: false, message: '请提供要格式化的文本内容', data: null };
      }

      // 使用文本内容作为缓存键
      const cacheKey = `formatelin_${text.trim()}`;

      // 1. 先查询缓存
      const cachedResult = await this.databaseService.getCacheByPrompt(cacheKey);
      if (cachedResult) {
        try {
          const parsedResult = JSON.parse(cachedResult);
          return {
            success: true,
            message: '格式化成功（缓存）',
            data: {
              sentences: parsedResult,
              originalText: text,
              timestamp: new Date().toISOString(),
              fromCache: true
            }
          };
        } catch (parseError) {
          console.error('缓存数据解析失败:', parseError);
          // 如果缓存数据解析失败，继续调用API
        }
      }

      // 2. 缓存中没有或解析失败，调用dmxapi接口
      const requestData = {
        max_tokens: 8192,
        model: "gemini-2.0-flash",
        temperature: 0.3, // 降低温度以获得更一致的结果
        top_p: 1,
        presence_penalty: 1,
        messages: [
          {
            role: "system",
            content: "你是一个专业的文本处理助手。 只是保留英文，请将用户提供的文本按照自然语言的语法规则，切割成独立的句子。每个句子应该是完整的、有意义的语句。请以JSON数组格式返回结果，数组中每个元素都是一个完整的句子字符串。"
          },
          {
            role: "user",
            content: ` 只是保留英文，请将以下文本切割成一句一句的话，以JSON数组格式返回：\n\n${text}\n\n要求：\n1. 每个句子都应该是完整的、有意义的\n2. 保持原文的语言风格和表达方式\n3. 返回格式必须是JSON数组，例如：["句子1", "句子2", "句子3"]\n4. 不要添加任何额外的解释或说明，只返回JSON数组`
          }
        ]
      };

      const response = await axios.post(
        this.apiConfig.url,
        requestData,
        {
          headers: this.apiConfig.headers,
          timeout: 30000 // 30秒超时
        }
      );
      
      const aiResult = response?.data?.choices?.[0]?.message?.content;

      if (!aiResult) {
        return { success: false, message: 'AI服务返回空结果', data: null };
      }

      // 3. 解析AI返回的JSON数组
      let sentences: string[] = [];
      try {
        // 尝试直接解析JSON
        const cleanResult = aiResult.trim();
        // 移除可能的markdown代码块标记
        const jsonMatch = cleanResult.match(/```(?:json)?\s*([\s\S]*?)\s*```/) || [null, cleanResult];
        const jsonStr = jsonMatch[1] || cleanResult;
        
        sentences = JSON.parse(jsonStr);
        
        // 验证结果是否为数组
        if (!Array.isArray(sentences)) {
          throw new Error('返回结果不是数组格式');
        }
        
        // 过滤空字符串和无效句子
        sentences = sentences.filter(sentence => 
          typeof sentence === 'string' && sentence.trim().length > 0
        ).map(sentence => sentence.trim());
        
      } catch (parseError) {
        console.error('解析AI返回结果失败:', parseError);
        console.log('原始AI返回内容:', aiResult);
        
        // 如果JSON解析失败，尝试简单的句子分割作为备选方案
        sentences = text.split(/[.!?。！？]\s*/).filter(s => s.trim().length > 0);
      }

      // 4. 保存结果到缓存
      if (sentences.length > 0) {
        await this.databaseService.saveCacheResult(cacheKey, JSON.stringify(sentences));
      }

      return {
        success: true,
        message: '格式化成功',
        data: {
          sentences: sentences,
          originalText: text,
          timestamp: new Date().toISOString(),
          fromCache: false
        }
      };

    } catch (error) {
      console.error('文本格式化错误:', error);
      return { success: false, message: '格式化失败，请重试', data: null };
    }
  }
}
